In `@app/build.gradle.kts`:
- Around line 33-40: The signingConfigs block uses properties["KEY"].toString()
which yields the literal "null" when keys are absent; update the release signing
config inside create("release") to use safe calls and explicit null handling for
storePassword, keyAlias and keyPassword (e.g.,
properties["STORE_PASSWORD"]?.toString() ?: error("STORE_PASSWORD not set") or
requireNotNull(properties["STORE_PASSWORD"]?.toString()) { "STORE_PASSWORD
missing" }) so missing local.properties entries fail fast with a clear error
instead of producing the "null" string.

In
`@core/common/src/main/java/com/neki/android/core/common/permission/NotificationPermissionManager.kt`:
- Around line 12-14: Rename/adjust the logic in
NotificationPermissionManager.isGrantedNotificationPermission to differentiate
runtime permission from notification enabled state: on Android S+ (SDK_INT >=
33) use ContextCompat.checkSelfPermission(context,
Manifest.permission.POST_NOTIFICATIONS) == PackageManager.PERMISSION_GRANTED to
determine POST_NOTIFICATIONS consent, otherwise fall back to
NotificationManagerCompat.from(context).areNotificationsEnabled(); keep the same
method name but ensure it checks permission for API 33+ and uses
areNotificationsEnabled() for older APIs so both concepts are handled.

In
`@core/domain/src/main/java/com/neki/android/core/domain/usecase/UploadProfileImageUseCase.kt`:
- Around line 18-21: When calling UploadProfileImageUseCase from
MyPageViewModel, determine the actual image MIME type from the provided Uri via
ContentResolver.getType(uri) (or ContentResolver.openInputStream+probe if
needed), map that MIME (e.g. "image/png", "image/jpeg", "image/webp") to the
domain ContentType enum, and pass the resulting ContentType into
UploadProfileImageUseCase.invoke(uri, contentType) instead of relying on the
default ContentType.JPEG; update the call site in MyPageViewModel to compute and
supply this contentType so files are named and uploaded with the correct image
format.

In
`@feature/mypage/impl/src/main/java/com/neki/android/feature/mypage/impl/main/MyPageScreen.kt`:
- Around line 40-42: The call to context.packageManager.getPackageInfo(...) in
MyPageScreen's appVersion remember block uses the deprecated API for API 33+;
update the retrieval to handle SDK >= 33 by calling
PackageManager.getPackageInfo with PackageManager.PackageInfoFlags.of(0L) and
fall back to the deprecated overload with `@Suppress`("DEPRECATION") for older
SDKs, or extract this logic into a helper/extension (e.g., a function like
getVersionName(context) used by MyPageScreen) to centralize compatibility
handling.

In
`@feature/mypage/impl/src/main/java/com/neki/android/feature/mypage/impl/main/MyPageViewModel.kt`:
- Around line 182-196: In signOut (MyPageViewModel.signOut) ensure the token
cache is invalidated on successful sign-out by invoking
AuthCacheManager.invalidateTokenCache() in the onSuccess block (after
tokenRepository.clearTokens()); update the onSuccess handler that currently
calls tokenRepository.clearTokens() and
postSideEffect(MyPageEffect.NavigateToLogin) to also call
AuthCacheManager.invalidateTokenCache() so the in-memory cache is cleared the
same way logout handles it.
- Around line 148-151: The parallel API calls built in the buildList block (the
async calls to userRepository.updateUserInfo and uploadProfileImageUseCase,
followed by awaitAll()) currently ignore per-call failures; change each async to
wrap the call in runCatching (e.g., async { runCatching {
userRepository.updateUserInfo(...) } } and async { runCatching {
uploadProfileImageUseCase(...) } }), awaitAll() to get List<Result<...>>, then
iterate the results to handle failures (log, emit UI error state or show a
user-facing message) and handle successes accordingly; refer to the async blocks
inside the buildList, the calls userRepository.updateUserInfo and
uploadProfileImageUseCase, and the awaitAll() usage in MyPageViewModel.kt.
- Around line 177-180: The logout implementation in MyPageViewModel currently
clears tokens via tokenRepository.clearTokens() but does not invalidate the Ktor
token cache; call AuthCacheManager.invalidateTokenCache() before posting the
NavigateToLogin effect so cached bearer tokens are wiped; update the logout
function to invoke AuthCacheManager.invalidateTokenCache() (or its
singleton/instance equivalent used in the codebase) then
tokenRepository.clearTokens() and finally
postSideEffect(MyPageEffect.NavigateToLogin).
- Around line 171-174: The onFailure handler in the MyPageViewModel currently
resets state and calls postSideEffect(MyPageEffect.NavigateBack), which hides
the screen with no user feedback; change the onFailure block to reset isLoading
and selectedProfileImage (keep the reduce call) but replace NavigateBack with an
error feedback effect (e.g., postSideEffect(MyPageEffect.ShowError(message)) or
similar) so the UI shows an error toast/dialog and stays on the screen; if
MyPageEffect lacks a ShowError variant, add one (e.g., ShowError(String) or
ShowError(`@StringRes` int)) and handle it in the view to display the error
message instead of navigating back.

In
`@feature/mypage/impl/src/main/java/com/neki/android/feature/mypage/impl/permission/PermissionScreen.kt`:
- Around line 70-77: The launcher callback in PermissionScreen.kt computes
isGranted with permissions.values.any { it }, which diverges from the
manager-based logic used in checkPermissions(); update the permissionLauncher
callback to determine the granted state the same way as checkPermissions():
first compute the permission type using
CameraPermissionManager.CAMERA_PERMISSION,
LocationPermissionManager.LOCATION_PERMISSIONS and
NotificationPermissionManager.NOTIFICATION_PERMISSION (as you already do), then
for each case call the same manager check used in checkPermissions() (e.g.,
NotificationPermissionManager.areNotificationsEnabled() for notifications and
the corresponding camera/location manager methods for those permissions) and
pass that boolean into
viewModel.store.onIntent(MyPageIntent.UpdatePermissionState(permission,
isGranted)).

In
`@feature/mypage/impl/src/main/java/com/neki/android/feature/mypage/impl/profile/component/SettingProfileImage.kt`:
- Around line 57-61: The Icon currently uses contentDescription = null which
makes the editable icon inaccessible; update the Icon (the composable that uses
Modifier.noRippleClickableSingle and onClickEdit) to provide a meaningful
contentDescription (e.g., use a string resource like R.string.edit_profile_image
or a descriptive literal "Edit profile image"/"프로필 사진 편집") so screen readers
announce the action; ensure you reference the same symbol (Icon with
Modifier.noRippleClickableSingle and onClickEdit) and use a localized string
resource rather than a hard-coded string.
- Around line 39-46: The AsyncImage in SettingProfileImage.kt uses profileImage
(a URL) as its model but doesn't specify placeholder or error images, so
failures leave the UI blank; import painterResource and pass painterResource(id
= R.drawable.image_empty_profile_image) to AsyncImage's placeholder and error
parameters (while keeping model = profileImage ?:
R.drawable.image_empty_profile_image) so the default drawable is shown on
load/failure and ensure the painterResource import is added at the top of the
file.

In
`@feature/mypage/impl/src/main/java/com/neki/android/feature/mypage/impl/profile/EditProfileScreen.kt`:
- Line 74: 현재 textFieldState =
rememberTextFieldState(uiState.userInfo.nickname)는 초기 composition에서만 초기값을 잡아
네트워크로 닉네임이 바뀌어도 반영되지 않습니다; 수정은 두 가지 중 하나로 하세요: 1) remember의 key로
uiState.userInfo.nickname을 사용해 textFieldState를 재생성(예:
remember(uiState.userInfo.nickname) {
rememberTextFieldState(uiState.userInfo.nickname) })하거나 2) 텍스트 값을 동기화하는 방식으로
LaunchedEffect(uiState.userInfo.nickname) 내부에서 textFieldState의 업데이트 메서드(예:
setText 또는 해당하는 변경 API)를 호출해 외부 닉네임 변경 시 TextField 상태를 갱신하세요; 대상 심볼:
rememberTextFieldState, textFieldState, uiState.userInfo.nickname,
LaunchedEffect.

In
`@feature/mypage/impl/src/main/java/com/neki/android/feature/mypage/impl/profile/ProfileSettingScreen.kt`:
- Around line 62-65: When calling SettingProfileImage, ensure an empty profile
URL is converted to null to avoid attempting to load an empty model: replace the
direct uiState.userInfo.profileImageUrl argument with a null-safe expression
(e.g., use takeIf { it.isNotBlank() }/ifBlank { null }) so SettingProfileImage
receives null when the string is empty; update the call site where
SettingProfileImage is invoked (referencing SettingProfileImage and
uiState.userInfo.profileImageUrl).

In `@gradle/libs.versions.toml`:
- Around line 40-41: Update the OSS Licenses dependency versions in
gradle/libs.versions.toml by changing the ossLicensesLib and ossLicensesPlugin
values to the latest releases; specifically set ossLicensesLib to 17.4.0 and
ossLicensesPlugin to 0.10.10 so the entries for ossLicensesLib and
ossLicensesPlugin reflect the updated versions.

In
`@core/data/src/main/java/com/neki/android/core/data/repository/impl/AuthRepositoryImpl.kt`:
- Around line 30-32: The function AuthRepositoryImpl.withdrawAccount declares
suspend fun withdrawAccount(): Result<Unit> but runSuspendCatching currently
returns a BasicNullableResponse<Unit> from authService.withdrawAccount(),
causing a type mismatch; inside the runSuspendCatching block (or immediately
after), unwrap the BasicNullableResponse<Unit> (e.g., access its .data or map
the response) and convert/return a Result<Unit> (or Result.success(Unit) when
data indicates success, or propagate the error) so the function signature
matches; locate runSuspendCatching and authService.withdrawAccount() in
AuthRepositoryImpl to implement the mapping/unwrapping.

In
`@feature/mypage/impl/src/main/java/com/neki/android/feature/mypage/impl/main/MyPageScreen.kt`:
- Around line 45-58: MyPageEffect.NavigateBack and MyPageEffect.NavigateToLogin
are currently no-ops inside the viewModel.store.sideEffects.collectWithLifecycle
block, so navigation is never performed; update the when-handling for these
cases to invoke the proper navigation callbacks (e.g., call an existing
navigateBack() or navigateToLogin() function or forward the effect to the parent
via the same mechanism used by navigateToProfile() / navigateToPermission()), or
propagate the effect so the host handles it, ensuring NavigateBack and
NavigateToLogin are no longer ignored.

In
`@feature/mypage/impl/src/main/java/com/neki/android/feature/mypage/impl/main/MyPageViewModel.kt`:
- Around line 128-130: The onFailure branch in MyPageViewModel.kt currently only
clears loading via reduce { copy(isLoading = false) } and lacks user feedback;
update the onFailure handler in the failing use-case callback (the block
containing reduce { copy(isLoading = false) }) to surface an error to the UI by
either setting an error field in the view state (e.g., reduce { copy(isLoading =
false, errorMessage = someUserFriendlyMessageFrom(it)) }) or invoking the
existing UI event/side-effect mechanism (e.g., emit a Toast/UiEvent) so
network/other errors are shown to the user.

In
`@core/common/src/main/java/com/neki/android/core/common/kakao/KakaoAuthHelper.kt`:
- Around line 14-29: The code force-unwraps token.idToken in both
UserApiClient.instance.loginWithKakaoTalk and loginWithKakaoAccount which can
cause NPE if idToken is null and also misses the case where error==null &&
token==null; refactor by extracting a single callback handler (e.g.,
handleKakaoLoginResult(token, error, onSuccess, onFailure)) used by both
loginWithKakaoTalk and loginWithKakaoAccount that: 1) checks if error != null ->
call onFailure(error.message ?: "카카오 로그인에 실패했습니다."), 2) else if token?.idToken
!= null -> call onSuccess(token.idToken), 3) else -> call onFailure with a clear
message about missing idToken (e.g., "idToken is null; ensure OIDC/openid scope
is enabled"); this removes duplication and avoids using token.idToken!!.

In
`@feature/mypage/impl/src/main/java/com/neki/android/feature/mypage/impl/main/MyPageContract.kt`:
- Line 12: The initial profileImageState is set to
EditProfileImageType.OriginalImageUrl("") but fetchInitialData's onSuccess
doesn't update it, so the UI won't reflect the server image; update the
ViewModel's fetchInitialData onSuccess reduce block to also set
profileImageState to EditProfileImageType.OriginalImageUrl(user.profileImageUrl)
(i.e., in the reduce { copy(...) } call alongside isLoading and userInfo) so the
ViewState's profileImageState is synchronized with the fetched user data.

In
`@feature/mypage/impl/src/main/java/com/neki/android/feature/mypage/impl/main/MyPageViewModel.kt`:
- Around line 146-149: The current MyPageViewModel branch calls
uploadProfileImageUseCase(uri = uri) when isProfileImageChanged is true but
casts profileImageState with as? EditProfileImageType.ImageUri which yields null
for EditProfileImageType.Default, causing an unintended null URI; update the
logic in MyPageViewModel so you explicitly branch on profileImageState (check
for EditProfileImageType.ImageUri vs EditProfileImageType.Default) — when
ImageUri present call uploadProfileImageUseCase with that non-null uri, when
Default either skip calling uploadProfileImageUseCase or call it with an
explicit sentinel/flag meaning “reset to default” and add a brief comment
documenting the chosen behavior (or, if null is intended, add a clarifying
comment explaining that uploadProfileImageUseCase(uri = null) denotes
default-reset).
- Around line 52-55: The ClickBackIcon branch sets profileImageState to
EditProfileImageType.OriginalImageUrl but the EditProfileScreen's LaunchedEffect
doesn't handle that case, so update the LaunchedEffect to handle
EditProfileImageType.OriginalImageUrl by setting displayProfileImage =
uiState.profileImageState.url (reference: MyPageIntent.ClickBackIcon,
profileImageState, EditProfileImageType.OriginalImageUrl, displayProfileImage,
LaunchedEffect in EditProfileScreen); also treat empty string URLs as null
before assigning (or map "" -> null) so AsyncImage's model ?: fallback will use
the fallback drawable when state.userInfo.profileImageUrl is empty.

In
`@feature/mypage/impl/src/main/java/com/neki/android/feature/mypage/impl/profile/EditProfileScreen.kt`:
- Around line 85-95: displayProfileImage is initialized with remember {
mutableStateOf(uiState.userInfo.profileImageUrl) } so it never updates when
userInfo.profileImageUrl changes, and the LaunchedEffect ignores the
OriginalImageUrl case; update the logic so OriginalImageUrl sets
displayProfileImage from the latest uiState.userInfo.profileImageUrl (or make
the remembered state depend on uiState.userInfo.profileImageUrl by using
remember(uiState.userInfo.profileImageUrl) { mutableStateOf(...) }) and in the
LaunchedEffect(uiState.profileImageState) handle
EditProfileImageType.OriginalImageUrl by assigning displayProfileImage =
uiState.userInfo.profileImageUrl so the UI reflects server-loaded image updates.

In
`@feature/mypage/impl/src/main/java/com/neki/android/feature/mypage/impl/profile/ProfileSettingScreen.kt`:
- Around line 46-57: The logout/unlink callbacks currently only call
navigateToLogin on onSuccess, causing the app to hang if kakaoAuthHelper.logout
or kakaoAuthHelper.unlink fails after tokenRepository.clearTokens() ran; update
the handlers in ProfileSettingScreen so both onSuccess and onFailure call
navigateToLogin (and still log the error in onFailure via Timber.e), i.e.,
change the onFailure lambdas for kakaoAuthHelper.logout and
kakaoAuthHelper.unlink to call navigateToLogin() after logging the error to
ensure the user is always routed to the login screen.

In
`@feature/mypage/impl/src/main/java/com/neki/android/feature/mypage/impl/main/MyPageViewModel.kt`:
- Around line 182-197: withdrawAccount's onFailure only clears loading and logs
the error, so the user gets no feedback; update the onFailure block to call
postSideEffect with an appropriate MyPageEffect (e.g., MyPageEffect.ShowError or
MyPageEffect.ShowToast) carrying a user-facing message (or the
throwable.message) and keep Timber.e(it) and reduce { copy(isLoading = false) }
as is; reference withdrawAccount, onFailure, postSideEffect, and MyPageEffect
when making the change so the UI can display the error to the user.
- Around line 152-174: The onSuccess handler of userRepository.getUserInfo()
currently only posts MyPageEffect.PreloadImageAndNavigateBack when
isProfileImageChanged is true, so when only the nickname changed
(isNicknameChanged==true and isProfileImageChanged==false) no navigation effect
is emitted; update the onSuccess block in MyPageViewModel.kt so that after
reducing state you post MyPageEffect.PreloadImageAndNavigateBack when
isProfileImageChanged is true, otherwise if isNicknameChanged is true post
MyPageEffect.NavigateBack (ensure you reference the existing flags
isProfileImageChanged and isNicknameChanged and the effects
MyPageEffect.PreloadImageAndNavigateBack / MyPageEffect.NavigateBack in the
userRepository.getUserInfo() onSuccess path).